#include <nlohmann/json.hpp>
#include <string>
#include <vector>
#include <map>
#include <type_traits>  // for std::decay_t

using json = nlohmann::json;

#define REFLECT_PP_FOREACH_1(f, _1) f(_1)
#define REFLECT_PP_FOREACH_2(f, _1, _2) f(_1); f(_2)
#define REFLECT_PP_FOREACH_3(f, _1, _2, _3) f(_1); f(_2); f(_3)
#define REFLECT_PP_FOREACH_4(f, _1, _2, _3, _4) f(_1); f(_2); f(_3); f(_4)
#define REFLECT_PP_FOREACH_5(f, _1, _2, _3, _4, _5) f(_1); f(_2); f(_3); f(_4); f(_5)
#define REFLECT_PP_FOREACH_6(f, _1, _2, _3, _4, _5, _6) f(_1); f(_2); f(_3); f(_4); f(_5); f(_6)
#define REFLECT_PP_FOREACH_7(f, _1, _2, _3, _4, _5, _6, _7) f(_1); f(_2); f(_3); f(_4); f(_5); f(_6); f(_7)
#define REFLECT_PP_FOREACH_8(f, _1, _2, _3, _4, _5, _6, _7, _8) f(_1); f(_2); f(_3); f(_4); f(_5); f(_6); f(_7); f(_8)
#define REFLECT_PP_FOREACH_9(f, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(_1); f(_2); f(_3); f(_4); f(_5); f(_6); f(_7); f(_8); f(_9)
#define REFLECT_PP_FOREACH_10(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(_1); f(_2); f(_3); f(_4); f(_5); f(_6); f(_7); f(_8); f(_9); f(_10)

#define REFLECT_PP_NARGS_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define REFLECT_PP_NARGS(...) REFLECT_PP_NARGS_IMPL(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

#define REFLECT_EXPAND(x) x
#define REFLECT_CONCAT_2(x, y) x##y
#define REFLECT_CONCAT(x, y) REFLECT_CONCAT_2(x, y)
#define REFLECT_PP_FOREACH(f, ...) REFLECT_EXPAND(REFLECT_CONCAT(REFLECT_PP_FOREACH_, REFLECT_PP_NARGS(__VA_ARGS__))(f, __VA_ARGS__))

template <class T>
struct reflect_trait {
    template<class Func>
    static constexpr void for_each_members(T& object, Func&& func) {
        object.for_each_members(func);
    }
    template<class Func>
    static constexpr void for_each_members(const T& object, Func&& func) {
        object.for_each_members(func);
    }
};

#define REFLECT_PER_MEMBER(x) \
    func(#x, x);

#define REFLECT(...) \
template <class Func> \
constexpr void for_each_members(Func&& func) { \
    REFLECT_PP_FOREACH(REFLECT_PER_MEMBER, __VA_ARGS__) \
} \
template <class Func> \
constexpr void for_each_members(Func&& func) const { \
    REFLECT_PP_FOREACH(REFLECT_PER_MEMBER, __VA_ARGS__) \
}

//======================================================

// 用于处理结构体中有模板参数的情况
#define REFLECT_TYPE_BEGIN(Type, ...) \
template <__VA_ARGS__> \
struct reflect_trait<Type> { \
    template<class Func> \
    static constexpr void for_each_members(Type& object, Func&& func) { \

#define REFLECT_TYPE_PER_MEMBER(Member) \
    func(#Member, object.Member); 

#define REFLECT_TYPE_END() \
    } \
}; \

// 用宏简化模板特化，支持不定参数个数
#define REFLECT_TYPE(Type, ...)\
REFLECT_TYPE_BEGIN(Type) \
REFLECT_PP_FOREACH(REFLECT_TYPE_PER_MEMBER, __VA_ARGS__) \
REFLECT_TYPE_END();

#define REFLECT_TYPE_TEMPLATED(Type, ...) \
REFLECT_EXPAND(REFLECT_TYPE_BEGIN Type) \
REFLECT_PP_FOREACH(REFLECT_TYPE_PER_MEMBER, __VA_ARGS__) \
REFLECT_TYPE_END();

//======================================================

inline std::string toString(const json& value)
{
    return value.dump();
}

inline json fromString(const std::string& json_str)
{
    return json::parse(json_str);
}

// concept 用于定义类型约束
template<class T>
concept is_struct = requires(T t) {
    t.for_each_members([](const char*, auto&) {});
};


//检测一个类型是否是某个模板（如 std::vector）的实例化的工具代码。

/*
作用：默认情况下，任何类型 T 都不是模板 U 的特化版本
参数：
T：要检查的具体类型（如 std::vector<int>）
U：模板模板参数，表示一个模板类（如 std::vector）
继承自 std::false_type：默认返回 false，表示不匹配
*/
template <typename T, template <typename...> class U>
struct is_specialization : std::false_type {};


/*
例：std::map<int, std::string>
匹配步骤：
T = std::map<int, std::string>
U = std::map（模板模板参数）
编译器尝试匹配特化版本 is_specialization<U<Args...>, U>：
U<Args...> 展开为 std::map<int, std::string>
Args... 推导为 int, std::string
匹配成功，继承 std::true_type，is_map_specialization_v 返回 true。
*/
template <template <typename...> class U, typename... Args>
struct is_specialization<U<Args...>, U> : std::true_type {};

//检查 T 是否是 std::vector 的特化版本（例如，std::vector<int>、std::vector<std::string> 等）。
template <typename T>
constexpr bool is_specialization_v = is_specialization<T, std::vector>::value;

template <typename T>
constexpr bool is_map_specialization_v = is_specialization<T, std::map>::value;

// 序列化
template<class T> requires (!is_struct<T> && !is_specialization_v<T> && !is_map_specialization_v<T>)
json serialize(const T& object) {
    return json(object);
}

template <typename T>
json serialize(const std::vector<T>& vec) {
    json root = json::array();
    for (const auto& item : vec) {
        root.push_back(serialize(item));
    }
    return root;
}

template <typename T>
json serialize(const std::map<std::string, T>& map) {
    json root = json::object();
    for (const auto& [key, value] : map) {
        root[key] = serialize(value);
    }
    return root;
}

template <class T> requires (is_struct<T>)
json serialize(const T& object) {
    json root = json::object();
    reflect_trait<T>::for_each_members(object, [&](const char* key, const auto& value) {
        root[key] = serialize(value);
    });
    return root;
}

// 反序列化
template<class T> requires (!is_struct<T>)
T deserialize(const json& root) {
    return root.get<T>();
}

template<class T> requires (is_struct<T>)
T deserialize(const json& root) {
    if (!root.is_object()) {
        throw std::runtime_error("JSON is not an object for struct deserialization");
    }
    T object;
    reflect_trait<T>::for_each_members(object, [&](const char* key, auto& value) {
        value = deserialize<std::decay_t<decltype(value)>>(root.at(key));
    });
    return object;
}